package com.idc.resource.help;

import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;

import java.util.*;
import java.util.concurrent.TimeUnit;

/**
 * redis K-V 操作
 * Created by Lijing on 2017/7/5.
 */
@Slf4j
@Service
public class RedisHelp {

    /** redis连接 */
    @Autowired
    private StringRedisTemplate redisTemplate;

    /**
     * 根据key 查询redis中存储的list对象
     * @param keyEnum key
     * @param clazz List中的泛型
     * @param <T> 泛型
     * @return 查询出结果转换的对象集合
     */
    public <T> List<T> queryListByKey(String keyEnum, Class<T> clazz) {
        log.info("queryListByKey request：{}", keyEnum);
        try {
            String resultStr = queryObjectByKey(keyEnum);
            if (StringUtils.isBlank(resultStr))
                return null;
            List<T> value = JSONObject.parseArray(resultStr, clazz);
            return value;
        } catch (Exception e){
            log.error("查找redis出现异常：{}", e);
        }
        return null;
    }

    /**
     * 新增redis数据(永不过期)
     * @param obj value
     * @param keyEnum key
     * @return 新增结果
     */
    public boolean insertObject(String keyEnum,Object obj) {
        return insertObject(keyEnum,obj, 0L);
    }

    /**
     * 新增redis记录
     * @param obj value
     * @param keyEnum key
     * @param timeout 失效时间(s)
     * @return true 新增成功  false 新增失败
     */
    public boolean insertObject( String keyEnum,Object obj,  long timeout) {
        try {
            String value = JSONObject.toJSONString(obj);
            redisTemplate.opsForValue().set(keyEnum,value,timeout,TimeUnit.SECONDS);
            return true;
        } catch (Exception e){
            log.error("添加redis出现异常：{}", e);
        }
        return false;
    }

    /**
     * 删除redis中的key
     * @param keyEnum key
     * @return true 删除成功 false 删除失败
     */
    public boolean deleteObject(String keyEnum) {
        try {
            redisTemplate.delete(keyEnum);
            return true;
        } catch (Exception e){
            log.error("删除redis指定key出现异常：{}", e);
        }
        return false;
    }

    /**
     * 更新redis中的key-value
     * @param obj value
     * @param keyEnums 多个key
     * @return true 更新成功 false 更新失败
     */
    public boolean modify(Object obj, String... keyEnums) {
        for (String key : keyEnums){
            insertObject( key,obj);
        }
        return true;
    }

    /**
     * 查询redis中的存储值(返回String)
     * @param keyEnum key
     * @return String类型的值
     */
    public String queryObjectByKey(String keyEnum) {
        try {
            return redisTemplate.opsForValue().get(keyEnum);
        } catch (Exception e){
            log.error("查找redis异常，key：{} 异常：{}", keyEnum, e);
        }
        return null;
    }

    /**
     * 查询redis中的值并转换成对象，查询失败则返回null
     * @param keyEnum key
     * @param clazz 需要转换的对象class
     * @param <T> 泛型
     * @return 查询结果
     */
    public <T> T queryObjectByKey(String keyEnum, Class<T> clazz) {
        try {
            String resultStr = queryObjectByKey(keyEnum);
            if (StringUtils.isBlank(resultStr)){
                return null;
            }
            T value = JSONObject.parseObject(resultStr, clazz);
            return value;
        } catch (Exception e){
            log.error("查找redis异常，key：{} 异常：{}", keyEnum, e);
        }
        return null;
    }

    /**
     * 设置redis中key的过期时间(s)
     * @param keyEnum key
     * @param timeOut 过期时间
     * @return true 成功 false 失败
     */
    public boolean expire(String keyEnum,long timeOut){
        try {
            redisTemplate.expire(keyEnum,timeOut, TimeUnit.SECONDS);
        }catch (Exception e){
            log.error("根据key:{},更新redis过期时间失败",keyEnum);
        }
        return false;
    }


}